package day07.Stream_demo;

import day01_IO_JDBC.demo_JDBC_users.Entity.Users;
import org.junit.Test;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.stream.Stream;


/*
*
* 代码结构分析
list.stream()                           // 1. 将List转换为Stream
    .map(users -> users.getUser_name()  // 2. 映射操作：提取用户名并转为大写
    .toUpperCase())
    .forEach(System.out::println);      // 3. 终端操作：打印每个元素
分步解析
1. list.stream()
将List<Users>集合转换为一个顺序流(Stream)
Stream是Java 8引入的新API，用于函数式处理集合数据
转换后可以使用各种流操作（中间操作和终端操作）

2. .map(users -> users.getUser_name().toUpperCase())
map()是一个中间操作，用于转换流中的元素
接收一个函数式接口Function<T,R>（这里用lambda表达式实现）
对每个Users对象执行以下操作：
users.getUser_name()：获取用户名
.toUpperCase()：将用户名转为大写
最终生成一个新的流Stream<String>，包含所有大写的用户名

3. .forEach(System.out::println)
forEach()是一个终端操作，会消费流中的元素
接收一个Consumer函数式接口（这里使用方法引用System.out::println）
对转换后的大写用户名流中的每个元素执行打印操作

等价传统写法
如果不使用Stream API，等效的传统Java代码会是：
for (Users user : list) {
    String upperName = user.getUser_name().toUpperCase();
    System.out.println(upperName);
}
Stream操作的特点
链式调用：可以连接多个操作形成处理管道
惰性求值：中间操作不会立即执行，只有终端操作才会触发实际计算
不可复用：Stream只能被消费一次
不修改源数据：所有操作都产生新流，不影响原始集合
*
*
*
* 代码结构分析
Stream<Integer> ageStream = list.stream().map(Users::getUserage);
1. list.stream()
将List<Users>集合转换为一个顺序流(Stream)
原始流中的每个元素都是Users对象

2. .map(Users::getUserage)
map()是一个中间操作，用于转换流中的元素
这里使用方法引用Users::getUserage，等价于lambda表达式user -> user.getUserage()
作用是从每个Users对象中提取userage属性值
将Stream<Users>转换为Stream<Integer>（假设userage是Integer类型）
*
*
*
* 代码结构分析
* list.stream()                                           // 1. 将 List 转为 Stream
    .sorted((o1, o2) -> Integer.compare(o2.getUserage(), o1.getUserage()))  // 2. 按年龄降序排序
    .forEach(System.out::println);                      // 3. 打印排序后的结果
分步解析
1. list.stream()
将 List<Users> 转换为 Stream<Users>，使其支持流式操作（如 sorted、forEach）。

2. .sorted((o1, o2) -> Integer.compare(o2.getUserage(), o1.getUserage()))
sorted() 是一个 中间操作，用于对流中的元素排序。
它接收一个 Comparator<Users> 来定义排序规则。
这里使用 lambda 表达式自定义比较逻辑：

o2.getUserage() 和 o1.getUserage()：
通过交换 o1 和 o2 的位置，实现 降序排序（默认 Integer.compare(o1, o2) 是升序）。
Integer.compare(a, b)：
返回
负数（如果 a < b）
0（如果 a == b）
正数（如果 a > b）

3. .forEach(System.out::println)
终端操作，遍历排序后的流并打印每个 Users 对象（调用其 toString() 方法）。
*
*
*
*
* */


public class ListDemo {
    @Test
    public void test(){
        List<Users> list= new ArrayList<>();
        Collections.addAll(list,
                new Users("season","1223",1,"187266022"),
                new Users("ooo","7536",2,"184956185"),
                new Users("onvrn","84196516",8,"11762529")
        );
//        获取姓名转为大写
        list.stream().map(users -> users.getUser_name().toUpperCase()).forEach(System.out::println);
//        获取id + 筛选 id> 5
        Stream<Integer> streamId= list.stream().map(Users::getId);
        streamId.filter(id -> id>5).forEach(System.out::println);
//            合并
        list.stream().map(Users::getId).filter(id -> id>5).forEach(System.out::println);

//        获取 id<5 的 所有用户信息
        list.stream().filter(users -> users.getId()<5).map(Users::toString).forEach(System.out::println);
//        获取id大于5岁的 用户名
        list.stream().filter(users -> users.getId()>5).map(Users::getUser_name).forEach(System.out::println);
//        对id进行倒序排序
        list.stream().sorted( (a, b) -> b.getId()- a.getId() ).forEach(System.out::println);
//        list.stream().sorted((o1, o2) -> Integer.compare(o2.getUserage(),o1.getUserage())).forEach(System.out::println);




    }
}
